פדרציית GraphQL: איחוי סכמות (Schema Stitching) - מדריך מקיף

בנוף המתפתח תמיד של פיתוח יישומים מודרני, הצורך בארכיטקטורות סקלביליות וקלות לתחזוקה הפך לחיוני. מיקרו-שירותים, עם המודולריות המובנית ויכולת הפריסה העצמאית שלהם, הופיעו כפתרון פופולרי. עם זאת, ניהול מספר רב של מיקרו-שירותים יכול להציג מורכבויות, במיוחד כשמדובר בחשיפת API מאוחד ליישומי לקוח. כאן נכנסת לתמונה פדרציית GraphQL, ובפרט, איחוי סכמות (Schema Stitching).

מהי פדרציית GraphQL?

פדרציית GraphQL היא ארכיטקטורה עוצמתית המאפשרת לכם לבנות API יחיד ומאוחד של GraphQL ממספר שירותי GraphQL בסיסיים (שלעיתים קרובות מייצגים מיקרו-שירותים). היא מאפשרת למפתחים לשאול נתונים על פני שירותים שונים כאילו היו גרף יחיד, מה שמפשט את חווית הלקוח ומפחית את הצורך בלוגיקת תזמור מורכבת בצד הלקוח.

קיימות שתי גישות עיקריות לפדרציית GraphQL:

• איחוי סכמות (Schema Stitching): זוהי גישה הכוללת שילוב של מספר סכמות GraphQL לסכמה אחת מאוחדת בשכבת ה-gateway. זוהי גישה מוקדמת יותר והיא מסתמכת על ספריות לניהול שילוב הסכמות והאצלת השאילתות.
• פדרציית אפולו (Apollo Federation): זוהי גישה עדכנית וחזקה יותר המשתמשת בשפת סכמה הצהרתית ומתכנן שאילתות ייעודי לניהול תהליך הפדרציה. היא מציעה תכונות מתקדמות כמו הרחבות טיפוסים, הנחיות מפתח (key directives) ומעקב מבוזר (distributed tracing).

מאמר זה מתמקד באיחוי סכמות (Schema Stitching), ובוחן את המושגים, היתרונות, המגבלות והיישום המעשי שלו.

הבנת איחוי סכמות (Schema Stitching)

איחוי סכמות הוא תהליך של מיזוג מספר סכמות GraphQL לסכמה אחת, קוהרנטית. סכמה מאוחדת זו פועלת כחזית (facade), המסתירה את מורכבות השירותים הבסיסיים מהלקוח. כאשר לקוח מגיש בקשה לסכמה המאוחדת, ה-gateway מנתב בצורה חכמה את הבקשה לשירות(ים) הבסיסי(ים) המתאימ(ים), מאחזר את הנתונים, ומשלב את התוצאות לפני החזרתן ללקוח.

חשבו על זה כך: יש לכם מספר מסעדות (שירותים), שכל אחת מהן מתמחה במטבחים שונים. איחוי סכמות הוא כמו תפריט אוניברסלי המשלב את כל המנות מכל מסעדה. כאשר לקוח (client) מזמין מהתפריט האוניברסלי, ההזמנה מנותבת בצורה חכמה למטבחי המסעדות המתאימות, האוכל מוכן, ולאחר מכן משולב למשלוח אחד עבור הלקוח.

מושגי מפתח באיחוי סכמות

• סכמות מרוחקות (Remote Schemas): אלו הן סכמות ה-GraphQL האינדיבידואליות של כל שירות בסיסי. כל שירות חושף סכמה משלו, המגדירה את הנתונים והפעולות שהוא מספק.
• Gateway (שער): ה-gateway הוא הרכיב המרכזי האחראי על איחוי הסכמות המרוחקות יחד וחשיפת הסכמה המאוחדת ללקוח. הוא מקבל בקשות לקוח, מנתב אותן לשירותים המתאימים ומשלב את התוצאות.
• מיזוג סכמות (Schema Merging): זהו תהליך שילוב הסכמות המרוחקות לסכמה אחת. לעיתים קרובות זה כולל שינוי שמות של טיפוסים ושדות כדי למנוע התנגשויות והגדרת קשרים בין טיפוסים על פני סכמות שונות.
• האצלת שאילתות (Query Delegation): כאשר לקוח מגיש בקשה לסכמה המאוחדת, ה-gateway צריך להאציל את הבקשה לשירות(ים) הבסיסי(ים) המתאימ(ים) כדי לאחזר את הנתונים. זה כרוך בתרגום שאילתת הלקוח לשאילתה שהשירות המרוחק יכול להבין.
• איסוף תוצאות (Result Aggregation): לאחר שה-gateway אחזר נתונים מהשירותים הבסיסיים, הוא צריך לשלב את התוצאות לתשובה אחת שניתן להחזיר ללקוח. לעיתים קרובות זה כרוך בשינוי הנתונים כך שיתאימו למבנה של הסכמה המאוחדת.

היתרונות של איחוי סכמות

איחוי סכמות מציע מספר יתרונות משכנעים לארגונים המאמצים ארכיטקטורת מיקרו-שירותים:

• API מאוחד: מספק API יחיד ועקבי ללקוחות, מפשט את גישת הנתונים ומפחית את הצורך של לקוחות לתקשר עם מספר שירותים ישירות. התוצאה היא חווית מפתח נקייה ואינטואיטיבית יותר.
• מורכבות מופחתת בצד הלקוח: הלקוחות צריכים לתקשר רק עם הסכמה המאוחדת, מה שמגן עליהם מפני המורכבויות של ארכיטקטורת המיקרו-שירותים הבסיסית. זה מפשט את הפיתוח בצד הלקוח ומפחית את כמות הקוד הנדרשת בלקוח.
• סקלביליות מוגברת: מאפשר לכם להרחיב (scale) שירותים אינדיבידואליים באופן עצמאי בהתבסס על הצרכים הספציפיים שלהם. זה משפר את הסקלביליות והעמידות הכוללת של המערכת. לדוגמה, שירות משתמשים שחווה עומס גבוה יכול להיות מורחב מבלי להשפיע על שירותים אחרים כמו קטלוג מוצרים.
• תחזוקתיות משופרת: מקדם מודולריות והפרדת תחומי אחריות, מה שמקל על תחזוקה ופיתוח של שירותים אינדיבידואליים. שינויים בשירות אחד נוטים פחות להשפיע על שירותים אחרים.
• אימוץ הדרגתי: ניתן ליישם באופן הדרגתי, מה שמאפשר לכם לעבור בהדרגה מארכיטקטורה מונוליטית לארכיטקטורת מיקרו-שירותים. אתם יכולים להתחיל על ידי איחוי של ממשקי API קיימים ולאחר מכן לפרק בהדרגה את המונוליט לשירותים קטנים יותר.

מגבלות של איחוי סכמות

בעוד שאיחוי סכמות מציע יתרונות רבים, חשוב להיות מודעים למגבלותיו:

• מורכבות: יישום וניהול של איחוי סכמות יכול להיות מורכב, במיוחד במערכות גדולות ומורכבות. תכנון ועיצוב קפדניים הם חיוניים.
• תקורה בביצועים: ה-gateway מציג תקורה מסוימת בביצועים עקב שכבת הביניים הנוספת והצורך להאציל שאילתות ולאסוף תוצאות. אופטימיזציה קפדנית חיונית כדי למזער תקורה זו.
• התנגשויות בסכמה: עלולות להיווצר התנגשויות בעת מיזוג סכמות משירותים שונים, במיוחד אם הם משתמשים באותם שמות טיפוסים או שדות. זה דורש עיצוב סכמה קפדני ופוטנציאלית שינוי שמות של טיפוסים ושדות.
• תכונות מתקדמות מוגבלות: בהשוואה לפדרציית אפולו, לאיחוי סכמות חסרות כמה תכונות מתקדמות כמו הרחבות טיפוסים והנחיות מפתח (key directives), מה שיכול להקשות על ניהול קשרים בין טיפוסים על פני סכמות שונות.
• בשלות הכלים: הכלים והאקוסיסטם סביב איחוי סכמות אינם בשלים כמו אלה סביב פדרציית אפולו. זה יכול להקשות על ניפוי באגים ופתרון בעיות.

יישום מעשי של איחוי סכמות

בואו נעבור על דוגמה מפושטת לאופן יישום איחוי סכמות באמצעות Node.js וספריית graphql-tools (בחירה פופולרית לאיחוי סכמות). דוגמה זו כוללת שני מיקרו-שירותים: שירות משתמשים ושירות מוצרים.

1. הגדרת הסכמות המרוחקות

ראשית, נגדיר את סכמות ה-GraphQL עבור כל אחד מהשירותים המרוחקים.

שירות משתמשים (user-service.js):

            
const { buildSchema } = require('graphql');

const userSchema = buildSchema(`
  type User {
    id: ID!
    name: String
    email: String
  }

  type Query {
    user(id: ID!): User
  }
`);

const users = [
  { id: '1', name: 'Alice Smith', email: 'alice@example.com' },
  { id: '2', name: 'Bob Johnson', email: 'bob@example.com' },
];

const userRoot = {
  user: (args) => users.find(user => user.id === args.id),
};

module.exports = {
  schema: userSchema,
  rootValue: userRoot,
};

            

              
                Copy
              
            
          

שירות מוצרים (product-service.js):

            
const { buildSchema } = require('graphql');

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Foreign key to User Service
  }

  type Query {
    product(id: ID!): Product
  }
`);

const products = [
  { id: '101', name: 'Laptop', price: 1200, userId: '1' },
  { id: '102', name: 'Smartphone', price: 800, userId: '2' },
];

const productRoot = {
  product: (args) => products.find(product => product.id === args.id),
};

module.exports = {
  schema: productSchema,
  rootValue: productRoot,
};

            

              
                Copy
              
            
          

2. יצירת שירות ה-Gateway

כעת, ניצור את שירות ה-gateway שיאחה את שתי הסכמות יחד.

שירות ה-Gateway (gateway.js):

            
const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { graphqlHTTP } = require('express-graphql');
const express = require('express');
const { introspectSchema } = require('@graphql-tools/wrap');
const { printSchema } = require('graphql');
const fetch = require('node-fetch');

async function createRemoteSchema(uri) {
  const fetcher = async (params) => {
    const response = await fetch(uri, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
    });
    return response.json();
  };

  const schema = await introspectSchema(fetcher);
  return makeRemoteExecutableSchema({
    schema,
    fetcher,
  });
}

async function main() {
  const userSchema = await createRemoteSchema('http://localhost:4001/graphql');
  const productSchema = await createRemoteSchema('http://localhost:4002/graphql');

  const stitchedSchema = stitchSchemas({
    subschemas: [
      { schema: userSchema },
      { schema: productSchema },
    ],
    typeDefs: `
      extend type Product {
        user: User
      }
    `,
    resolvers: {
      Product: {
        user: {
          selectionSet: `{ userId }`,
          resolve(product, args, context, info) {
            return info.mergeInfo.delegateToSchema({
              schema: userSchema,
              operation: 'query',
              fieldName: 'user',
              args: {
                id: product.userId,
              },
              context,
              info,
            });
          },
        },
      },
    },
  });

  const app = express();
  app.use('/graphql', graphqlHTTP({
    schema: stitchedSchema,
    graphiql: true,
  }));

  app.listen(4000, () => console.log('Gateway server running on http://localhost:4000/graphql'));
}

main().catch(console.error);

            

              
                Copy
              
            
          

3. הרצת השירותים

תצטרכו להריץ את שירות המשתמשים ושירות המוצרים בפורטים שונים. לדוגמה:

שירות משתמשים (פורט 4001):

            
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./user-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4001, () => console.log('User service running on http://localhost:4001/graphql'));

            

              
                Copy
              
            
          

שירות מוצרים (פורט 4002):

            
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./product-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4002, () => console.log('Product service running on http://localhost:4002/graphql'));

            

              
                Copy
              
            
          

4. שליחת שאילתה לסכמה המאוחדת

כעת אתם יכולים לשלוח שאילתה לסכמה המאוחדת דרך ה-gateway (הרצה על פורט 4000). תוכלו להריץ שאילתה כזו:

            
query {
  product(id: "101") {
    id
    name
    price
    user {
      id
      name
      email
    }
  }
}

            

              
                Copy
              
            
          

שאילתה זו מאחזרת את המוצר עם מזהה "101" וגם מביאה את המשתמש המשויך משירות המשתמשים, מה שמדגים כיצד איחוי סכמות מאפשר לכם לשאול נתונים על פני מספר שירותים בבקשה אחת.

טכניקות מתקדמות לאיחוי סכמות

מעבר לדוגמה הבסיסית, הנה כמה טכניקות מתקדמות שניתן להשתמש בהן כדי לשפר את יישום איחוי הסכמות שלכם:

• האצלת סכמה (Schema Delegation): זה מאפשר לכם להאציל חלקים משאילתה לשירותים שונים בהתבסס על הנתונים המבוקשים. לדוגמה, ייתכן שתאצילו את הרזולוציה של טיפוס `User` לשירות המשתמשים ואת הרזולוציה של טיפוס `Product` לשירות המוצרים.
• טרנספורמציית סכמה (Schema Transformation): זה כולל שינוי סכמה של שירות מרוחק לפני שהיא מאוחה לסכמה המאוחדת. זה יכול להיות שימושי לשינוי שמות של טיפוסים ושדות, הוספת שדות חדשים או הסרת שדות קיימים.
• רזולברים מותאמים אישית: אתם יכולים להגדיר רזולברים מותאמים אישית ב-gateway כדי לטפל בטרנספורמציות נתונים מורכבות או כדי לאחזר נתונים ממספר שירותים ולשלב אותם לתוצאה אחת.
• שיתוף קונטקסט (Context Sharing): לעיתים קרובות יש צורך לשתף מידע קונטקסט בין ה-gateway לשירותים המרוחקים, כגון אסימוני אימות או מזהי משתמש. ניתן להשיג זאת על ידי העברת מידע קונטקסט כחלק מתהליך האצלת השאילתה.
• טיפול בשגיאות: יש ליישם טיפול חזק בשגיאות כדי להתמודד בחן עם שגיאות המתרחשות בשירותים המרוחקים. זה עשוי לכלול רישום שגיאות, החזרת הודעות שגיאה ידידותיות למשתמש או ניסיון חוזר של בקשות שנכשלו.

בחירה בין איחוי סכמות לפדרציית אפולו

בעוד שאיחוי סכמות הוא אפשרות בת-קיימא לפדרציית GraphQL, פדרציית אפולו הפכה לבחירה הפופולרית יותר בזכות התכונות המתקדמות וחווית המפתח המשופרת שלה. הנה השוואה בין שתי הגישות:

מתי לבחור באיחוי סכמות:

• יש לכם שירותי GraphQL קיימים ואתם רוצים לשלב אותם במהירות.
• אתם זקוקים לפתרון פדרציה פשוט ואינכם דורשים תכונות מתקדמות.
• יש לכם משאבים מוגבלים ואתם רוצים להימנע מהתקורה של הקמת פדרציית אפולו.

מתי לבחור בפדרציית אפולו:

• אתם בונים מערכת גדולה ומורכבת עם צוותים ושירותים מרובים.
• אתם זקוקים לתכונות מתקדמות כמו הרחבות טיפוסים, הנחיות מפתח ומעקב מבוזר.
• אתם רוצים פתרון פדרציה חזק וסקלבילי יותר.
• אתם מעדיפים גישה הצהרתית ואוטומטית יותר לפדרציה.

דוגמאות מהעולם האמיתי ומקרי שימוש

הנה כמה דוגמאות מהעולם האמיתי לאופן שבו ניתן להשתמש בפדרציית GraphQL, כולל איחוי סכמות:

• פלטפורמת מסחר אלקטרוני: פלטפורמת מסחר אלקטרוני עשויה להשתמש בפדרציית GraphQL כדי לשלב נתונים ממספר שירותים, כגון שירות קטלוג מוצרים, שירות משתמשים, שירות הזמנות ושירות תשלומים. זה מאפשר ללקוחות לאחזר בקלות את כל המידע שהם צריכים כדי להציג פרטי מוצר, פרופילי משתמש, היסטוריית הזמנות ופרטי תשלום.
• פלטפורמת מדיה חברתית: פלטפורמת מדיה חברתית יכולה להשתמש בפדרציית GraphQL כדי לשלב נתונים משירותים המנהלים פרופילי משתמש, פוסטים, תגובות ולייקים. זה מאפשר ללקוחות לאחזר ביעילות את כל המידע הנדרש כדי להציג פרופיל של משתמש, את הפוסטים שלו, ואת התגובות והלייקים המשויכים לאותם פוסטים.
• יישום שירותים פיננסיים: יישום שירותים פיננסיים עשוי להשתמש בפדרציית GraphQL כדי לשלב נתונים משירותים המנהלים חשבונות, עסקאות והשקעות. זה מאפשר ללקוחות לאחזר בקלות את כל המידע שהם צריכים כדי להציג יתרות חשבון, היסטוריית עסקאות ותיקי השקעות.
• מערכת ניהול תוכן (CMS): מערכת CMS יכולה למנף את פדרציית GraphQL כדי לשלב נתונים ממקורות שונים כמו מאמרים, תמונות, סרטונים ותוכן שנוצר על ידי משתמשים. זה מאפשר API מאוחד לאחזור כל התוכן הקשור לנושא או מחבר ספציפי.
• יישום בתחום הבריאות: שלבו נתוני מטופלים ממערכות שונות כמו רשומות רפואיות אלקטרוניות (EHR), תוצאות מעבדה וזימון תורים. זה מציע לרופאים נקודת גישה יחידה למידע מקיף על המטופל.

שיטות עבודה מומלצות לאיחוי סכמות

כדי להבטיח יישום מוצלח של איחוי סכמות, עקבו אחר שיטות העבודה המומלצות הבאות:

• תכננו את הסכמה שלכם בקפידה: לפני שאתם מתחילים לאחות סכמות יחד, תכננו בקפידה את מבנה הסכמה המאוחדת. זה כולל הגדרת הקשרים בין טיפוסים על פני סכמות שונות, שינוי שמות של טיפוסים ושדות כדי למנוע התנגשויות, והתחשבות בדפוסי הגישה לנתונים הכוללים.
• השתמשו במוסכמות שיום עקביות: אמצו מוסכמות שיום עקביות עבור טיפוסים, שדות ופעולות בכל השירותים. זה יעזור למנוע התנגשויות ויקל על הבנת הסכמה המאוחדת.
• תעדו את הסכמה שלכם: תעדו את הסכמה המאוחדת ביסודיות, כולל תיאורים של טיפוסים, שדות ופעולות. זה יקל על מפתחים להבין ולהשתמש בסכמה.
• נטרו את הביצועים: נטרו את ביצועי ה-gateway והשירותים המרוחקים כדי לזהות ולטפל בכל צוואר בקבוק בביצועים. השתמשו בכלים כמו מעקב מבוזר כדי לעקוב אחר בקשות על פני מספר שירותים.
• יישמו אבטחה: ישמו אמצעי אבטחה מתאימים כדי להגן על ה-gateway והשירותים המרוחקים מגישה לא מורשית. זה עשוי לכלול שימוש במנגנוני אימות והרשאה, וכן אימות קלט וקידוד פלט.
• נהלו גרסאות לסכמה שלכם: ככל שאתם מפתחים את הסכמות שלכם, נהלו להן גרסאות כראוי כדי להבטיח שלקוחות יוכלו להמשיך להשתמש בגרסאות ישנות יותר של הסכמה מבלי להישבר. זה יעזור למנוע שינויים שוברים ולהבטיח תאימות לאחור.
• הפכו את הפריסה לאוטומטית: הפכו את פריסת ה-gateway והשירותים המרוחקים לאוטומטית כדי להבטיח שניתן לפרוס שינויים במהירות ובאמינות. זה יעזור להפחית את הסיכון לשגיאות ולשפר את הזריזות הכוללת של המערכת.

סיכום

פדרציית GraphQL עם איחוי סכמות מציעה גישה עוצמתית לבניית ממשקי API מאוחדים ממספר שירותים בארכיטקטורת מיקרו-שירותים. על ידי הבנת מושגי הליבה, היתרונות, המגבלות וטכניקות היישום שלה, תוכלו למנף את איחוי הסכמות כדי לפשט את הגישה לנתונים, לשפר את הסקלביליות ולהגביר את התחזוקתיות. בעוד שפדרציית אפולו הופיעה כפתרון מתקדם יותר, איחוי סכמות נותר אפשרות בת-קיימא לתרחישים פשוטים יותר או בעת שילוב שירותי GraphQL קיימים. שקלו בקפידה את הצרכים והדרישות הספציפיות שלכם כדי לבחור את הגישה הטובה ביותר לארגון שלכם.